package cn.zyq.ykb.system.task.delayQueue;

import cn.hutool.core.date.DateTime;
import cn.hutool.core.date.DateUtil;
import cn.zyq.ykb.beans.task.TaskOrder;
import cn.zyq.ykb.service.config.ConfigPropService;
import cn.zyq.ykb.service.product.ProductOrderService;
import cn.zyq.ykb.service.product.ProductService;
import cn.zyq.ykb.service.task.TaskOrderService;
import cn.zyq.ykb.service.task.TaskService;
import com.alibaba.fastjson.JSON;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.DelayQueue;
import java.util.concurrent.Executors;

/**
 * 延时任务管理类DelayQueueManager
 */
@Component
public class DelayQueueManager implements CommandLineRunner {
    private final Logger logger = LoggerFactory.getLogger(DelayQueueManager.class);
    private DelayQueue<DelayTask> delayQueue = new DelayQueue<>();
     @Autowired
     private TaskOrderService taskOrderService;
    @Autowired
    private ConfigPropService configPropService;
    @Autowired
    private TaskService taskService;
    @Autowired
    private ProductOrderService productOrderService;
    /**
     * 加入到延时队列中
     *
     * @param task
     */
    public void put(DelayTask task) {
        logger.info("加入延时任务：{}", JSON.toJSONString(task));
        delayQueue.put(task);
    }

    /**
     * 取消延时任务
     *
     * @param task
     * @return
     */
    public boolean remove(DelayTask task) {
        logger.info("取消延时任务：{}", JSON.toJSONString(task));
        return delayQueue.remove(task);
    }

    /**
     * 取消延时任务
     *
     * @param taskid
     * @return
     */
    public boolean remove(String taskid) {
        return remove(new DelayTask(new TaskBase(taskid), 0));
    }

    @Override
    public void run(String... args) throws Exception {
        logger.info("初始化延时队列");
        Executors.newSingleThreadExecutor().execute(new Thread(this::excuteThread));
        //重启，重新加载
        /**
         * 为了防止机器重启导致内存中的DelayQueue数据丢失，每次机器启动的时候，需要从数据库中初始化未结束的订单，加入到DelayQueue中。
         */
        this.reloadTask();
    }


    /**
     * 延时任务执行线程
     */
    private void excuteThread() {
        while (true) {
            try {
                DelayTask task = delayQueue.take();
                processTask(task);
            } catch (InterruptedException e) {
                break;
            }
        }
    }

    private void reloadTask(){
        //加载未支付任务订单
        this.taskOrderService.reloadStateQueue();
         //加载未支付的道具订单
        this.configPropService.reloadStateQueue();
        //加载未完成的任务
        this.taskService.reloadStateQueue();
        //加载未支付的任务订单
        this.productOrderService.reloadStateQueue();

    }

    /**
     * 内部执行延时任务
     *
     * @param task
     */
    private void processTask(DelayTask task) {
        logger.info("执行延时任务：{}", JSON.toJSONString(task));
        //根据task中的data自定义数据来处理相关逻辑，例 if (task.getData() instanceof XXX) {}
        TaskBase data = task.getData();
        if (data.getType().equals(1)){
            //订单过期
            this.taskOrderService.checkExpire(data.getServiceID());
        }else if (data.getType().equals(2)){
            //购买道具过期
            this.configPropService.checkExpire(data.getServiceID());
        }else if (data.getType().equals(3)){
            //任务过期
            this.taskService.checkExpire(data.getServiceID());
        }else{
        }
    }


}
